// 定义实现者特质 `Implementor`，规定了操作实现的接口。
trait Implementor {
    fn operation_impl(&self) -> String; // 定义了一个返回字符串的操作实现方法
}

// 具体实现者 `ConcreteImplementorA` 结构体，实现了 `Implementor` 特质。
struct ConcreteImplementorA;

// 实现 `Implementor` 特质的 `operation_impl()` 方法，返回特定字符串。
impl Implementor for ConcreteImplementorA {
    fn operation_impl(&self) -> String {
        "ConcreteImplementorA".to_string()
    }
}

// 具体实现者 `ConcreteImplementorB` 结构体，实现了 `Implementor` 特质。
struct ConcreteImplementorB;

// 实现 `Implementor` 特质的 `operation_impl()` 方法，返回特定字符串。
impl Implementor for ConcreteImplementorB {
    fn operation_impl(&self) -> String {
        "ConcreteImplementorB".to_string()
    }
}

// 抽象类 `Abstraction` 结构体，包含一个指向 `Implementor` 特质的动态对象。
struct Abstraction {
    implementor: Box<dyn Implementor>, // 持有一个实现者对象的动态实例
}

// `Abstraction` 结构体的实现。
impl Abstraction {
    // 构造函数 `new()`，初始化抽象类对象并传入实现者对象。
    fn new(implementor: Box<dyn Implementor>) -> Self {
        Self { implementor }
    }

    // 操作方法 `operation()`，调用实现者对象的操作实现方法并返回结果。
    fn operation(&self) -> String {
        self.implementor.operation_impl() // 调用实现者对象的操作实现方法
    }
}

// 主函数入口 `main()`，演示桥接模式的使用。
pub fn main() {
    let impl_a = ConcreteImplementorA; // 创建具体实现者 A 对象
    let abstraction_a = Abstraction::new(Box::new(impl_a)); // 创建抽象类 A 对象，传入实现者 A
    println!("AbstractionA: {}", abstraction_a.operation()); // 调用抽象类 A 的操作方法，并打印结果

    let impl_b = ConcreteImplementorB; // 创建具体实现者 B 对象
    let abstraction_b = Abstraction::new(Box::new(impl_b)); // 创建抽象类 B 对象，传入实现者 B
    println!("AbstractionB: {}", abstraction_b.operation()); // 调用抽象类 B 的操作方法，并打印结果
}
